package cn.dglydrpy.fundmanagement.constant;

import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 标的类型枚举
 * <p>
 * 映射关系：
 * 1-稳健灵活 11-余额宝, 12-余利宝, 13-月利宝
 * 2-黄金 21-工行积存金
 * 3-基金 31-指数基金, 32-偏债基金, 33-偏股基金, 34-全球基金, 35-黄金基金
 * 4-股票 41-主板股票, 42-创业板股票, 43-科创板股票, 43-北证股票, 44-港交所股票
 * 5-ETF 51-大盘ETF, 52-行业ETF,53-策略ETF
 */
public enum FundTypeEnum {
    
    // 稳健灵活类型 (1)
    STEADY_FLEXIBLE("1", "稳健灵活", new SubType[]{
            new SubType("11", "余额宝"),
            new SubType("12", "余利宝"),
            new SubType("13", "月利宝")
    }),
    
    // 黄金类型 (2)
    GOLD("2", "黄金", new SubType[]{
            new SubType("21", "工行积存金")
    }),
    
    // 基金类型 (3)
    FUND("3", "基金", new SubType[]{
            new SubType("31", "指数基金"),
            new SubType("32", "偏债基金"),
            new SubType("33", "偏股基金"),
            new SubType("34", "全球基金"),
            new SubType("35", "黄金基金")
    }),
    
    // 股票类型 (4)
    STOCK("4", "股票", new SubType[]{
            new SubType("41", "主板股票"),
            new SubType("42", "创业板股票"),
            new SubType("43", "科创板股票"),
            new SubType("44", "北证股票"),
            new SubType("45", "港交所股票")
    }),
    
    // ETF类型 (5)
    ETF("5", "ETF", new SubType[]{
            new SubType("51", "大盘ETF"),
            new SubType("52", "行业ETF"),
            new SubType("53", "策略ETF")
    });

    private final String code;
    private final String name;
    private final SubType[] subTypes;

    FundTypeEnum(String code, String name, SubType[] subTypes) {
        this.code = code;
        this.name = name;
        this.subTypes = subTypes;
    }

    public String getCode() {
        return code;
    }

    public String getName() {
        return name;
    }

    public SubType[] getSubTypes() {
        return subTypes;
    }

    /**
     * 根据代码获取标的类型枚举
     *
     * @param code 标的类型代码
     * @return 对应的枚举值，如果未找到则返回null
     */
    public static FundTypeEnum fromCode(String code) {
        for (FundTypeEnum type : FundTypeEnum.values()) {
            if (type.getCode().equals(code)) {
                return type;
            }
        }
        return null;
    }

    /**
     * 获取指定类型下的子类型
     *
     * @param typeCode     标的类型代码
     * @param subTypeCode  子类型代码
     * @return 对应的子类型，如果未找到则返回null
     */
    public static SubType getSubType(String typeCode, String subTypeCode) {
        FundTypeEnum fundType = fromCode(typeCode);
        if (fundType != null) {
            for (SubType subType : fundType.getSubTypes()) {
                if (subType.getCode().equals(subTypeCode)) {
                    return subType;
                }
            }
        }
        return null;
    }

    /**
     * 获取指定类型下的所有子类型
     *
     * @param typeCode 标的类型代码
     * @return 对应的子类型数组
     */
    public static SubType[] getSubTypesByType(String typeCode) {
        FundTypeEnum fundType = fromCode(typeCode);
        return fundType != null ? fundType.getSubTypes() : new SubType[0];
    }

    /**
     * 获取标的类型和子类型的完整映射关系
     *
     * @return 映射关系
     */
    public static Map<String, String> getFullTypeMapping() {
        return Arrays.stream(values())
                .collect(Collectors.toMap(
                        FundTypeEnum::getCode,
                        FundTypeEnum::getName
                ));
    }

    /**
     * 子类型内部类
     */
    public static class SubType {
        private final String code;
        private final String name;

        public SubType(String code, String name) {
            this.code = code;
            this.name = name;
        }

        public String getCode() {
            return code;
        }

        public String getName() {
            return name;
        }

        /**
         * 获取完整代码（类型代码_子类型代码）
         *
         * @param typeCode 类型代码
         * @return 完整代码
         */
        public String getFullCode(String typeCode) {
            return typeCode + "_" + code;
        }

        @Override
        public String toString() {
            return code + "-" + name;
        }
    }
}